package Greedy;

import java.util.Arrays;
import java.util.List;
import java.util.function.ToIntFunction;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * @ClassName LargestSumAfterKNegations
 * @Description TODO
 * @Author lenovo
 * @Date 2023-06-13 10:40
 * @Version 1.0
 * @Comment Magic. Do not touch.
 * If this comment is removed. the program will blow up
 */
public class LargestSumAfterKNegations {

    /**
     * 1005. K 次取反后最大化的数组和
     * 给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：
     * <p>
     * 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。
     * 重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
     * <p>
     * 以这种方式修改数组后，返回数组 可能的最大和 。
     * <p>
     * <p>
     * <p>
     * 示例 1：
     * <p>
     * 输入：nums = [4,2,3], k = 1
     * 输出：5
     * 解释：选择下标 1 ，nums 变为 [4,-2,3] 。
     * 示例 2：
     * <p>
     * 输入：nums = [3,-1,0,2], k = 3
     * 输出：6
     * 解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。
     * 示例 3：
     * <p>
     * 输入：nums = [2,-3,-1,5,-4], k = 2
     * 输出：13
     * 解释：选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4] 。
     *
     * @param nums
     * @param k
     * @return
     */
    public int largestSumAfterKNegations(int[] nums, int k) {
        Integer[] result = new Integer[]{1, 2, 3, 4, 5};
        List<Integer> list = Arrays.asList(result);

        /**
         * 按照数的绝对值从大到小排列，遇到负号的改为﹢号，如果k还没有用完，就将最后一个数反转，最后一个数最小影响最小。
         */
        int[] numArray = IntStream.of(nums)
                .boxed().sorted((x, y) -> Math.abs(y) - Math.abs(x)).mapToInt(new ToIntFunction<Integer>() {
                    @Override
                    public int applyAsInt(Integer value) {
                        return value.intValue();
                    }
                }).toArray();

        int[] int1s = IntStream.of(nums)
                .boxed().sorted((x, y) -> Math.abs(y) - Math.abs(x)).mapToInt(Integer::intValue).toArray();
        for (int i = 0; i < numArray.length; i++) {
            //遇到负数变为正数
            if (numArray[i] < 0 && k > 0) {
                numArray[i] = -numArray[i];
                k--;
            }
        }
        //如果k剩余取最小的数来反转
        if (k % 2 == 1) numArray[nums.length - 1] = -numArray[nums.length - 1];
        return Arrays.stream(numArray).sum();

    }

    public static void main(String[] args) {
        LargestSumAfterKNegations largestSumAfter = new LargestSumAfterKNegations();
        System.out.println(largestSumAfter.largestSumAfterKNegations(new int[]{3, -1, 0, 2}, 2));
    }
}